/******************************************************************************
    头文件
******************************************************************************/
#include "tic10024_reg.h"
#include "tic10024_api.h"
#include "Loncin_Uart.h"

/******************************************************************************
    文件内部使用的宏
******************************************************************************/

/******************************************************************************
    局部函数声明
******************************************************************************/

/******************************************************************************
    全局变量定义
******************************************************************************/

/******************************************************************************
    局部变量定义
******************************************************************************/

/******************************************************************************
    局部函数实现
******************************************************************************/

/******************************************************************************
    全局函数实现
******************************************************************************/

/**
 * \brief 初始化TIC10024设备
 *
 * 该函数用于初始化TIC10024设备，包括获取设备ID、关闭监测、配置通道、配置轮询模式、
 * 配置轮询时间和激活时间、配置润湿电流和比较器阈值，并最后启动监测。
 */
void tic10024_init(void)
{
    // 获取设备ID
    uint32_t device_id = tic10024_device_id_get();
    LOG_DEBUG("device_id: %x\n", device_id);

    // 关闭监测
    tic10024_trigger_set(false);

    // 关闭所有通道
    tic10024_channel_in_en_set(CHANNEL_ALL, false);

    // 清除所有通道湿电流
    tic10024_channel_ccp_cfg1_set(CHANNEL_ALL, false);

    // 配置通道
    tic10024_channel_in_en_set(CHANNEL_ALL, true);

    // 配置轮询模式
    tic10024_poll_mode_set(true);

    // 配置轮询时间
    tic10024_poll_time_config(POLL_TIME_8MS);

    // 配置轮询激活时间
    tic10024_poll_act_time_config(POLL_ACT_TIME_512US);

    // 配置润湿电流
    tic10024_channel_wetting_current_config(CHANNEL_ALL, WC_5MA);

    // 配置比较器
    tic10024_channel_threshold_config(CHANNEL_ALL, THRESHOLD_2V);

    // 配置中断使能寄存器0
    tic10024_int_en_cfg0_set(true);

    // 启动监测
    tic10024_trigger_set(true);
}

/**
 * \brief 获取tic10024设备的ID
 *
 * 从tic10024设备的寄存器中读取设备ID。
 *
 * \return 返回设备的ID，类型为uint32_t
 */
uint32_t tic10024_device_id_get(void)
{
    uint32_t device_id = tic10024_reg_read(REG_DEVICE_ID);

    return device_id;
}

/**
 * \brief 设置 TIC10024 输入通道使能状态
 *
 * 设置 TIC10024 输入通道的使能状态。如果指定 CHANNEL_ALL，则对所有输入通道进行操作。
 *
 * \param channel 输入通道编号，可以是单个通道编号或 CHANNEL_ALL
 * \param enable 使能状态，true 表示使能，false 表示禁用
 */
void tic10024_channel_in_en_set(tic_channel channel, bool enable)
{
    // 读取输入使能寄存器
    uint32_t en_reg = tic10024_reg_read(REG_IN_EN);

    // 判断是否对所有通道进行操作
    if (CHANNEL_ALL == channel)
    {
        // 如果启用所有通道
        if (enable)
        {
            // 将输入使能寄存器设置为全1
            tic10024_reg_write(REG_IN_EN, 0xFFFFFF);
        }
        // 如果禁用所有通道
        else
        {
            // 将输入使能寄存器设置为全0
            tic10024_reg_write(REG_IN_EN, 0x000000);
        }
    }
    // 对单个通道进行操作
    else
    {
        // 如果启用指定通道
        if (enable)
        {
            // 再次将指定通道的位设置为1
            en_reg |= (1U << channel);
        }
        // 如果禁用指定通道
        else
        {
            // 将指定通道的位清零
            en_reg &= ~(1U << channel);
        }
        // 将更新后的输入使能寄存器写回
        tic10024_reg_write(REG_IN_EN, en_reg);
    }
}

/**
 * \brief 配置tic10024的通道润湿电流
 *
 * 该函数用于配置tic10024设备的指定通道或所有通道的润湿电流。
 *
 * \param channel 需要配置的通道，可以是单个通道（CHANNEL_0到CHANNEL_23）或所有通道（CHANNEL_ALL）
 * \param current 需要设置的润湿电流值
 */
void tic10024_channel_wetting_current_config(tic_channel channel, wetting_current current)
{
    // 定义并初始化寄存器变量
    uint32_t wc_reg = 0;

    // 根据通道号选择对应的配置逻辑
    switch (channel)
    {
    case CHANNEL_0:
    case CHANNEL_1:
    {
        // 读取REG_WC_CFG0寄存器的当前值
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_0和CHANNEL_1对应的湿电流位域（保留其他位不变）
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN0_IN1_SHIFT);

        // 将新的湿电流值写入对应位域
        wc_reg |= current << WC_CFG0_WC_IN0_IN1_SHIFT;

        // 将修改后的值写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_2:
    case CHANNEL_3:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_2和CHANNEL_3对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN2_IN3_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN2_IN3_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_4:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_4对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN4_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN4_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_5:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_5对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN5_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN5_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_6:
    case CHANNEL_7:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_6和CHANNEL_7对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN6_IN7_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN6_IN7_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_8:
    case CHANNEL_9:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_8和CHANNEL_9对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN8_IN9_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN8_IN9_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_10:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_10对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN10_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN10_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_11:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG0);

        // 清除CHANNEL_11对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG0_WC_IN11_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG0_WC_IN11_SHIFT;

        // 写回REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);
        break;
    }

    case CHANNEL_12:
    case CHANNEL_13:
    {
        // 读取REG_WC_CFG1寄存器的当前值
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_12和CHANNEL_13对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN12_IN13_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN12_IN13_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_14:
    case CHANNEL_15:
    {
        // 读取REG_WC_CFG1寄存器的当前值
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_14和CHANNEL_15对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN14_IN15_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN14_IN15_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_16:
    case CHANNEL_17:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_16和CHANNEL_17对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN16_IN17_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN16_IN17_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_18:
    case CHANNEL_19:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_18和CHANNEL_19对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN18_IN19_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN18_IN19_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_20:
    case CHANNEL_21:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_20和CHANNEL_21对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN20_IN21_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN20_IN21_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_22:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_22对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN22_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN22_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_23:
    {
        wc_reg = tic10024_reg_read(REG_WC_CFG1);

        // 清除CHANNEL_23对应的湿电流位域
        wc_reg &= ~(0x7U << WC_CFG1_WC_IN23_SHIFT);

        // 设置新的湿电流值到对应位域
        wc_reg |= current << WC_CFG1_WC_IN23_SHIFT;

        // 写回REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
        break;
    }

    case CHANNEL_ALL:
    {
        // 初始化寄存器为0
        wc_reg = 0;

        // 对于REG_WC_CFG0中的所有通道，设置相同的湿电流值
        wc_reg |= (current << WC_CFG0_WC_IN0_IN1_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN2_IN3_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN4_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN5_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN6_IN7_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN8_IN9_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN10_SHIFT);
        wc_reg |= (current << WC_CFG0_WC_IN11_SHIFT);

        // 将配置写入REG_WC_CFG0寄存器
        tic10024_reg_write(REG_WC_CFG0, wc_reg);

        // 重新初始化寄存器为0
        wc_reg = 0;

        // 对于REG_WC_CFG1中的所有通道，设置相同的湿电流值
        wc_reg |= (current << WC_CFG1_WC_IN12_IN13_SHIFT);
        wc_reg |= (current << WC_CFG1_WC_IN14_IN15_SHIFT);
        wc_reg |= (current << WC_CFG1_WC_IN16_IN17_SHIFT);
        wc_reg |= (current << WC_CFG1_WC_IN18_IN19_SHIFT);
        wc_reg |= (current << WC_CFG1_WC_IN20_IN21_SHIFT);
        wc_reg |= (current << WC_CFG1_WC_IN22_SHIFT);
        wc_reg |= (current << WC_CFG1_WC_IN23_SHIFT);

        // 将配置写入REG_WC_CFG1寄存器
        tic10024_reg_write(REG_WC_CFG1, wc_reg);
    }
    default:
        // 默认情况不执行任何操作
        break;
    }
}

/**
 * \brief 配置TIC10024芯片的通道比较器阈值
 *
 * 该函数用于配置TIC10024芯片的通道比较器阈值。
 *
 * \param channel 要配置的通道
 * - CHANNEL_0 到 CHANNEL_23: 分别对应0到23号通道
 * - CHANNEL_ALL: 配置所有通道
 * \param threshold 要设置的比较器阈值
 */
void tic10024_channel_threshold_config(tic_channel channel, comparator_threshold threshold)
{
    // 读取比较器阈值寄存器
    uint32_t thres_reg = tic10024_reg_read(REG_THRES_COMP);

    switch (channel)
    {
    case CHANNEL_0:
    case CHANNEL_1:
    case CHANNEL_2:
    case CHANNEL_3:
    {
        // 清除通道0-3的阈值位
        thres_reg &= ~(0x3 << THRES_COMP_IN0_IN3_SHIFT);
        // 设置通道0-3的阈值
        thres_reg |= (threshold << THRES_COMP_IN0_IN3_SHIFT);
        break;
    }

    case CHANNEL_4:
    case CHANNEL_5:
    case CHANNEL_6:
    case CHANNEL_7:
    {
        // 清除通道4-7的阈值位
        thres_reg &= ~(0x3 << THRES_COMP_IN4_IN7_SHIFT);
        // 设置通道4-7的阈值
        thres_reg |= (threshold << THRES_COMP_IN4_IN7_SHIFT);
        break;
    }

    case CHANNEL_8:
    case CHANNEL_9:
    case CHANNEL_10:
    case CHANNEL_11:
    {
        // 清除通道8-11的阈值位
        thres_reg &= ~(0x3 << THRES_COMP_IN8_IN11_SHIFT);
        // 设置通道8-11的阈值
        thres_reg |= (threshold << THRES_COMP_IN8_IN11_SHIFT);
        break;
    }

    case CHANNEL_12:
    case CHANNEL_13:
    case CHANNEL_14:
    case CHANNEL_15:
    {
        // 清除通道12-15的阈值位
        thres_reg &= ~(0x3 << THRES_COMP_IN12_IN15_SHIFT);
        // 设置通道12-15的阈值
        thres_reg |= (threshold << THRES_COMP_IN12_IN15_SHIFT);
        break;
    }

    case CHANNEL_16:
    case CHANNEL_17:
    case CHANNEL_18:
    case CHANNEL_19:
    {
        // 清除通道16-19的阈值位
        thres_reg &= ~(0x3 << THRES_COMP_IN16_IN19_SHIFT);
        // 设置通道16-19的阈值
        thres_reg |= (threshold << THRES_COMP_IN16_IN19_SHIFT);
        break;
    }

    case CHANNEL_20:
    case CHANNEL_21:
    case CHANNEL_22:
    case CHANNEL_23:
    {
        // 清除通道20-23的阈值位
        thres_reg &= ~(0x3 << THRES_COMP_IN20_IN23_SHIFT);
        // 设置通道20-23的阈值
        thres_reg |= (threshold << THRES_COMP_IN20_IN23_SHIFT);
        break;
    }

    case CHANNEL_ALL:
    {
        // 清除所有通道的阈值位并设置新的阈值
        // 通道0-3
        thres_reg &= ~(0x3 << THRES_COMP_IN0_IN3_SHIFT);
        thres_reg |= (threshold << THRES_COMP_IN0_IN3_SHIFT);
        // 通道4-7
        thres_reg &= ~(0x3 << THRES_COMP_IN4_IN7_SHIFT);
        thres_reg |= (threshold << THRES_COMP_IN4_IN7_SHIFT);
        // 通道8-11
        thres_reg &= ~(0x3 << THRES_COMP_IN8_IN11_SHIFT);
        thres_reg |= (threshold << THRES_COMP_IN8_IN11_SHIFT);
        // 通道12-15
        thres_reg &= ~(0x3 << THRES_COMP_IN12_IN15_SHIFT);
        thres_reg |= (threshold << THRES_COMP_IN12_IN15_SHIFT);
        // 通道16-19
        thres_reg &= ~(0x3 << THRES_COMP_IN16_IN19_SHIFT);
        thres_reg |= (threshold << THRES_COMP_IN16_IN19_SHIFT);
        // 通道20-23
        thres_reg &= ~(0x3 << THRES_COMP_IN20_IN23_SHIFT);
        thres_reg |= (threshold << THRES_COMP_IN20_IN23_SHIFT);
        break;
    }
    default:
        break;
    }

    // 将新的阈值写回比较器阈值寄存器
    tic10024_reg_write(REG_THRES_COMP, thres_reg);
}

/**
 * \brief 设置tic10024芯片的清除当前轮询寄存器1通道湿电流的使能状态
 *
 * 该函数用于设置tic10024芯片的清除当前轮询寄存器1通道湿电流的使能状态。
 *
 * \param channel 要设置的通道。如果为CHANNEL_ALL，则表示对所有通道进行操作。
 * \param enable 是否使能该通道。true表示使能，false表示禁用。
 */
void tic10024_channel_ccp_cfg1_set(tic_channel channel, bool enable)
{
    // 读取清除当前轮询寄存器1的值
    uint32_t ccp_cfg1_reg = tic10024_reg_read(REG_CCP_CFG1);

    // 判断是否对所有通道进行操作
    if (CHANNEL_ALL == channel)
    {
        // 如果启用所有通道
        if (enable)
        {
            // 将寄存器设置为全1
            tic10024_reg_write(REG_CCP_CFG1, 0xFFFFFF);
        }
        // 如果禁用所有通道
        else
        {
            // 将寄存器设置为全0
            tic10024_reg_write(REG_CCP_CFG1, 0x000000);
        }
    }
    // 对单个通道进行操作
    else
    {
        // 如果启用指定通道
        if (enable)
        {
            // 再次将指定通道的位设置为1
            ccp_cfg1_reg |= (1U << channel);
        }
        // 如果禁用指定通道
        else
        {
            // 将指定通道的位清零
            ccp_cfg1_reg &= ~(1U << channel);
        }
        // 将更新后的使能寄存器写回
        tic10024_reg_write(REG_CCP_CFG1, ccp_cfg1_reg);
    }
}

/**
 * \brief 读取指定通道的状态
 *
 * 该函数用于读取TIC10024设备指定通道的状态。
 *
 * \param channel 要读取的通道，可以是CHANNEL_A, CHANNEL_B等，或者使用CHANNEL_ALL读取所有通道的状态
 *
 * \return 如果channel为CHANNEL_ALL，返回所有通道的状态（32位），否则返回指定通道的状态（0或1）
 */
uint32_t tic10024_channel_status_read(tic_channel channel)
{
    uint32_t stat = tic10024_reg_read(REG_IN_STAT_COMP);

    if (CHANNEL_ALL == channel)
    {
        return stat;
    }
    else
    {
        return (stat >> channel) & 1;
    }
}

/**
 * \brief tic10024的软复位函数
 *
 * 该函数用于对tic10024进行软件复位。
 *
 * 首先读取CONFIG寄存器的值，然后将CONFIG_RESET_BIT位设置到该值中，
 * 并将新值写回CONFIG寄存器，从而触发复位操作。
 *
 * 接着，通过轮询INT_STAT寄存器的最低位（即POR标志位），
 * 等待该位被清除，表示复位操作已完成。
 */
void tic10024_soft_reset(void)
{
    uint32_t wc_reg = tic10024_reg_read(REG_CONFIG);

    tic10024_reg_write(REG_CONFIG, wc_reg | CONFIG_RESET_BIT);

    while (tic10024_reg_read(REG_INT_STAT) & (1U << 0))
        ; /* 等待POR标志清除 */
}

/**
 * \brief 设置TIC10024触发器的启用状态
 *
 * 该函数用于设置TIC10024控制器的触发器启用状态。
 *
 * \param enable 触发器的启用状态，true表示启用，false表示禁用
 */
void tic10024_trigger_set(bool enable)
{
    // 读取配置寄存器的内容
    uint32_t config = tic10024_reg_read(REG_CONFIG);

    // 如果需要启用触发器
    if (enable)
    {
        // 将配置寄存器的触发器位设置为1
        config |= CONFIG_TRIGGER_BIT;
    }
    else
    {
        // 将配置寄存器的触发器位清零
        config &= ~CONFIG_TRIGGER_BIT;
    }

    // 将修改后的配置写回配置寄存器
    tic10024_reg_write(REG_CONFIG, config);
}

/**
 * \brief 设置 TIC10024 的轮询模式
 *
 * 设置 TIC10024 是否进入轮询模式。
 *
 * \param enable 是否启用轮询模式，true 表示启用，false 表示禁用
 */
void tic10024_poll_mode_set(bool enable)
{
    // 读取配置寄存器的内容
    uint32_t config = tic10024_reg_read(REG_CONFIG);

    // 如果启用轮询模式
    if (enable)
    {
        // 设置轮询模式使能位
        config |= CONFIG_POLL_EN_BIT;
    }
    else
    {
        // 清除轮询模式使能位
        config &= ~CONFIG_POLL_EN_BIT;
    }

    // 将更新后的配置写回配置寄存器
    tic10024_reg_write(REG_CONFIG, config);
}

/**
 * \brief 配置TIC10024的轮询时间
 *
 * 该函数用于配置TIC10024的轮询时间。通过修改配置寄存器中的相应位来实现。
 *
 * \param time 轮询时间参数，其值决定了轮询的间隔时间。
 */
void tic10024_poll_time_config(poll_time time)
{
    uint32_t config = tic10024_reg_read(REG_CONFIG);
    config &= ~(0xF << CONFIG_POLL_TIME_SHIFT);
    config |= (time << CONFIG_POLL_TIME_SHIFT);
    tic10024_reg_write(REG_CONFIG, config);
}

/**
 * \brief 配置tic10024的轮询激活时间
 *
 * 该函数用于配置tic10024设备的轮询激活时间。
 *
 * \param time 轮询激活时间。
 */
void tic10024_poll_act_time_config(poll_act_time time)
{
    uint32_t config = tic10024_reg_read(REG_CONFIG);
    config &= ~(0xF << CONFIG_POLL_ACT_TIME_SHIFT);
    config |= (time << CONFIG_POLL_ACT_TIME_SHIFT);
    tic10024_reg_write(REG_CONFIG, config);
}

/**
 * \brief 设置TIC10024中断使能配置寄存器0
 *
 * 该函数用于设置TIC10024的中断使能配置寄存器0，以启用或禁用该寄存器中的所有中断。
 *
 * \param enable 是否启用中断，true表示启用，false表示禁用
 */
void tic10024_int_en_cfg0_set(bool enable)
{
    // 读取中断使能配置寄存器0的值
    uint32_t int_en_cfg0_reg = tic10024_reg_read(REG_INT_EN_CFG0);

    if (enable)
    {
        // 如果启用中断，将寄存器值设置为全1
        int_en_cfg0_reg |= 0xFF;
    }
    else
    {
        // 如果禁用中断，将寄存器值清零
        int_en_cfg0_reg &= ~0xFF;
    }

    // 将更新后的值写回中断使能配置寄存器0
    tic10024_reg_write(REG_INT_EN_CFG0, int_en_cfg0_reg);
}

/**
 * \brief 测试tic10024设备的功能
 *
 * 该函数初始化tic10024设备，并在一个无限循环中读取设备状态。当步数增加到200000的倍数时，读取所有通道的状态，
 * 并记录tic10024设备的各个状态标志。
 *
 * \return 无返回值
 */
int tic10024_test(void)
{
    // 初始化tic10024设备
    tic10024_init();

    uint32_t step = 0;

    while (1)
    {
        if (step++ % 200000 == 0)
        {
            uint32_t status = tic10024_channel_status_read(CHANNEL_ALL);

            // 状态为打开，执行相应操作
            LOG_DEBUG("channel channel status 0x%x\n", status);

            LOG_DEBUG("tic10024 status %d %d %d %d %d %d %d\n",
                      g_tic10024_status.STATUS.POR,
                      g_tic10024_status.STATUS.SPI_FAIL,
                      g_tic10024_status.STATUS.PRTY_FAIL,
                      g_tic10024_status.STATUS.SSC,
                      g_tic10024_status.STATUS.RES,
                      g_tic10024_status.STATUS.TEMP,
                      g_tic10024_status.STATUS.OI);
        }
    }
}
/* end of file */
